Try it out

15 + 5

## [1] 20

Mix operators

(15 + 5) / (2 * 5)

## [1] 2

Note: when we put a hash tag in front of our code then that is a comment.

Comments are just a useful way for us to add some text to our code, for example to explain what we are doing.

## I will be ignored
2*2*2

## [1] 8

## And so will I

An animal data set appears..

But adding up numbers for no reason is no fun.

That’s why we will use a data set about animals to learn some R Basics.

Animal Ageing and Longevity Database (John Snow Labs)

Data on over 4200 animals.

Information on age of maturity, gestation or incubation periods but also longevity (in years).

Animal Lifespan Data

Say you want to know how old an animal is in human years.

We can use the following simple formula to determine that:

\(\frac{\text{Maximum lifespan human}}{\text{Maximum lifespan non-human animal}} = \text{animal to human years conversion ratio}\)

Note: This is just a very rough way to determine the conversion ratio. It is much more complicated in reality.

Why are we using longevity instead of.. let’s say average life expectancy?

According to the Animal Ageing and Longevity Database (John Snow Labs):

“[…] [M]aximum longevity (also called maximum lifespan) […] is the most widely used parameter for comparing the rate of aging between species.”

First some important data points.

Human Longevity

The longest human to ever live is a woman named: Jeanne Calment. The french woman reached the age of 122 (!). She was born in 1875 and lived until 1997.

Animal Longevity Stats

Here is a table of maximum longevity for various animals:

Source: Animal Ageing and Longevity Database.

122.5/24

## [1] 5.104167

5.104167*15

## [1] 76.56251

Cat to Human years

1. Calculate cats to human years conversion ratio using objects
2. How old is a 15 year old cat in “human years”?

Note that object names could be anything here! I chose to go with short but self-explanatory names but I could have chosen to just name them x, y or z.

A note on naming stuff

\[\color{blue}{\text{"There are only two hard things in Computer Science:}}\] \[\color{blue}{\text{cache invalidation and naming things. ~ Phil Karlton"}}\]

Artist: Allison Horst

There are many approaches to name things in programming.

In this case we will be using a technique called lower snake case, which is also part of the tidyverse style guide.

Use underscores (_) to separate lower case letter words within a name.

Example:

# Recommended
animal_lifespan

# Not recommended
AnimalLifespan
animal.lifespan

Equal

== asks whether two values are the same or equal

lion_lifespan == boar_lifespan

## [1] TRUE

The code above tests the following statement: > The lifespan of a lion equals the lifespan of a boar.

Since both maximum lifespans are 27 this is of course a TRUE statement.

Not Equal

!= asks whether two values are the not the same or unequal

lion_lifespan != boar_lifespan

## [1] FALSE

The code above tests the reverse of the above statement: > The lifespan of a lion does not equal the lifespan of a boar.

Since both maximum lifespans are 27 this is of course a FALSE statement.

Greater or Smaller

We can also test whether certain values are greater or smaller than others:

> greater than

human_lifespan > fly_lifespan

## [1] TRUE

The code above tests the statement: > The lifespan of a human is greater than the lifespan of a fly.

Since the maximum human lifespan is 122.5 and a fly does not live longer than 0.3 years this is of course a TRUE statement.

alligator_lifespan < mouse_lifespan

## [1] FALSE

The code above tests the statement: > The lifespan of an alligator is smaller than the lifespan of a mouse.

Since the maximum alligator lifespan is 77 and a mouse lives for 4 years maximum, this is of course a FALSE statement.

Also note the following options:

• >= greater or equals
• <= smaller or equals

20 >= 20

## [1] TRUE

Small note on Variable Types

There are four main types of variables:

• logical: Boolean/binary, is either TRUE or FALSE

class(TRUE)

## [1] "logical"

• character (or string): simple text, including symbols and numbers "text"

class("I am a character")

## [1] "character"

• numeric: Numbers. Mathmatical operators can be used here.

class(2020)

## [1] "numeric"

• factor: characters or strings but ordered in some way

class(as.factor(c("I", "am", "a", "factor")))

## [1] "factor"

Another important value to know is NA. It stands for “Not Available” and simply denotes a missing value.

There also more like dates and datetimes but we won’t focus on that now.

c(NA, 1, 2, NA)

## [1] NA  1  2 NA

A logical operator for vectors: %in%

An incredibly useful operator for vectors is %in%.

The operator checks whether multiple elements occur somewhere in your vectors.

This basic usage looks like this:

\(\color{red}{\text{vector1}}\) %in% \(\color{orange}{\text{vector2}}\)

Let’s first create a vector called animals which includes all the animals in the same

animals <- c("greenland_shark", "dog", 
  "galapagos_tortoise", "mouse", 
  "fly", "lion", "boar",
  "alligator", "human")

Let’s say we want to check whether giraffe, greenland_shark or lion occur in animals.

If we use | we would have to write something like this:

animals == "giraffe" | animals == "greenland_shark"  | animals == "lion"

## [1]  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE

With %in% we can simply pass a vector like this:

animals_to_check <-  c("giraffe", "greenland_shark", "lion")
animals %in% animals_to_check

## [1]  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE

Where (if at all) does greenlands_shark or giraffe occur within our animals vector?

animals %in%  c("greenland_shark", "giraffe") 

## [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

This might not look too important of an improvement. But what if we had dozens or hundreds of animals to check?

animals == "honey_bee" | animals == "cardiocondyla_obscurior" | animals == "black_garden_ant" | animals == "pheidole_dentata" | animals == "squinting_bush_brown" | animals == "american_lobster" | animals == "firebelly_toad" | animals == "oriental_firebelly_toad" | animals == "yellow_bellied_toad" | animals == "greenland_shark" | animals == "western_toad" | animals == "yosemite_toad" | animals == "great_plains_toad" | animals == "green_toad" | animals == "canadian_toad" | animals == "red_spotted_toad" | animals == "sonoran_green_toad" | animals == "southern_toad" | animals == "veragoa_stubfoot_toad" | animals == "common_european_toad" | animals == "colorado_river_toad" | animals == "kihansi_spray_toad" | animals == "ridge_headed_toad" | animals == "cuban_toad" | animals == "european_green_toad" | animals == "colombian_giant_toad" | animals == "argentine_toad" | animals == "cane_toad" | animals == "eurura_toad" | animals == "common_horned_frog" | animals == "colombian_horned_frog" | animals == "amazonian_horned_frog" | animals == "ornate_horned_frog" | animals == "green_and_black_dart_poison_frog" 

## [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

With %in% it’s much more readable:

animals_to_check <-  c("honey_bee", "cardiocondyla_obscurior", "black_garden_ant", "pheidole_dentata", "squinting_bush_brown", "american_lobster", "firebelly_toad", "oriental_firebelly_toad", "yellow_bellied_toad",  "greenland_shark", "western_toad", "yosemite_toad", "great_plains_toad", "green_toad", "canadian_toad", "red_spotted_toad", "sonoran_green_toad", "southern_toad", "veragoa_stubfoot_toad", "common_european_toad",  "colorado_river_toad", "kihansi_spray_toad", "ridge_headed_toad", "cuban_toad", "european_green_toad","colombian_giant_toad", "argentine_toad", "cane_toad", "eurura_toad", "common_horned_frog", "colombian_horned_frog", "amazonian_horned_frog", "ornate_horned_frog")

animals %in% animals_to_check

## [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

Indexing with logical tests

You can also index using logical tests.

So if an expression evaluates to TRUE it will keep that element and when it evaluates to FALSE it will remove the element.

\[\color{red}{\text{vector}}[\color{orange}{\text{vector of TRUE/FALSE of same length}}]\]

Let’s first take a look at a logical test that extracts all animals that have greater lifespans than humans:

animal_lifespans > human_lifespan

## [1]  TRUE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE

Now we can use square brackets to only keep those animals that have greater lifespans than humans.

animals[animal_lifespans > human_lifespan]

## [1] "greenland_shark"    "galapagos_tortoise"

The Star Producer

Let’s consider the following function (that does not exist unfortunately): A star_producer!

This little machine creates tiny hand-drawn stars depending on some input. It takes two arguments:

• how_many tells the machine how many stars to produce
• type tells the machine how the stars should look like (in this case the machine only supports "squiggly" stars but it could be upgraded in the future when we learn how to create our own functions later on)

Note: just like levers or numpads you also have to be careful what value type an argument expects. You can’t type numbers into a lever and a numpad doesn’t do much when you pull it (other than break). Similarly, a certain argument might require you to input a numeric value, or more complex R objects.

Get ?help

But how do you know which function takes what kind of values?

You can find the documentation of a function when you type in ?function_name. This should tell you about the arguments, how to use the function and what to expect from its output.

Example function: seq

Let’s try this with a function that is included in every fresh R installation: seq.

?seq

From the description we can learn that this function is used to

“[g]enerate regular sequences”.

Its first three arguments are this:

• from, to: the starting and (maximal) end values of the sequence.

• by: number: increment of the sequence.

So we specify from when to where our sequence should go and by which number it should increment.

Let’s first take a look at this within our machine allegory.

Image

If we would want to create a vector from 1 to 10 that increments by 1 we can simple specify the following input values for the arguments:

• from: 1
• to: 10
• by: 1

This is how that looks like in code:

seq(from = 1, to = 10, by = 1)

##  [1]  1  2  3  4  5  6  7  8  9 10

seq(to = 10, by = 1, from = 1)

##  [1]  1  2  3  4  5  6  7  8  9 10

seq(1, 10, 1)

##  [1]  1  2  3  4  5  6  7  8  9 10

More examples: Mean and Median

In fact, most of the time functions have such intuitive structures that we often wouldn’t need to even look up the documentation (even though it’s advisable to do).

An easy function to use is mean which simply calculates the average of a numeric vectors.

Let’s try this with the animal_lifespans we created earlier.

mean(animal_lifespans)

## [1] 94.53333

Quite old mean value!

median(animal_lifespans)

## [1] 27

Well when we take the median instead of the mean we can see that this is due to high outliers (the median is of course more robust to extreme values).

There are of course many more functions in R and we will get to learn some of them during this workshop.

Square functions

Let’s define a function which squares numeric values.

square <- function(number_to_be_squared) { 
  
  squared_number <- number_to_be_squared^2

  return(squared_number)                  
  
}

square(4)

## [1] 16

Tip: In RStudio we can just type fun and enter after the popup and RStudio will just automatically generate a template for a function.

Dog to Human years function

Let’s create a function that is able to calculate dog years into human years. We call the function dog_to_human_years.

dog_to_human_years <- function(animal_years){

  human_lifespan <- 122.5
  dog_lifespan <- 24

  ratio <- human_lifespan/dog_lifespan

  human_years <- animal_years*ratio

  return(human_years)
}

dog_to_human_years(8)

## [1] 40.83333

Works perfect!

A quick note on errors and debugging

Artist: Allison Horst

So you encountered an error:

## Error: object of type 'closure' is not subsettable

Steps to take:

• Try to understand what it says.

• Google (or other search engines)

  • Search for the error
  • Search for what you were trying to do (add R or rstats)

• If the error occurs in a function check whether you passed an object type that isn’t expected by it.

  • Checking the documentation can help here! Type: ?function

• Ask for help! Create a reproducible example (reprex) and post to online communities

  • Stackoverflow
  • Twitter (use #rstats)
  • RStudio community (forum)

Artist: Allison Horst